home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Ubuntu 9.10 PL / karmelkowy-koliberek-desktop-9.10-i386-PL.iso / casper / filesystem.squashfs / usr / include / linux / wimax / i2400m.h
C/C++ Source or Header  |  2009-10-16  |  16KB  |  582 lines
  1. /*
  2.  * Intel Wireless WiMax Connection 2400m
  3.  * Host-Device protocol interface definitions
  4.  *
  5.  *
  6.  * Copyright (C) 2007-2008 Intel Corporation. All rights reserved.
  7.  *
  8.  * Redistribution and use in source and binary forms, with or without
  9.  * modification, are permitted provided that the following conditions
  10.  * are met:
  11.  *
  12.  *   * Redistributions of source code must retain the above copyright
  13.  *     notice, this list of conditions and the following disclaimer.
  14.  *   * Redistributions in binary form must reproduce the above copyright
  15.  *     notice, this list of conditions and the following disclaimer in
  16.  *     the documentation and/or other materials provided with the
  17.  *     distribution.
  18.  *   * Neither the name of Intel Corporation nor the names of its
  19.  *     contributors may be used to endorse or promote products derived
  20.  *     from this software without specific prior written permission.
  21.  *
  22.  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  23.  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  24.  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  25.  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  26.  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  27.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  28.  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  29.  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  30.  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  31.  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  32.  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  33.  *
  34.  *
  35.  * Intel Corporation <linux-wimax@intel.com>
  36.  * Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>
  37.  *  - Initial implementation
  38.  *
  39.  *
  40.  * This header defines the data structures and constants used to
  41.  * communicate with the device.
  42.  *
  43.  * BOOTMODE/BOOTROM/FIRMWARE UPLOAD PROTOCOL
  44.  *
  45.  * The firmware upload protocol is quite simple and only requires a
  46.  * handful of commands. See drivers/net/wimax/i2400m/fw.c for more
  47.  * details.
  48.  *
  49.  * The BCF data structure is for the firmware file header.
  50.  *
  51.  *
  52.  * THE DATA / CONTROL PROTOCOL
  53.  *
  54.  * This is the normal protocol spoken with the device once the
  55.  * firmware is uploaded. It transports data payloads and control
  56.  * messages back and forth.
  57.  *
  58.  * It consists 'messages' that pack one or more payloads each. The
  59.  * format is described in detail in drivers/net/wimax/i2400m/rx.c and
  60.  * tx.c.
  61.  *
  62.  *
  63.  * THE L3L4 PROTOCOL
  64.  *
  65.  * The term L3L4 refers to Layer 3 (the device), Layer 4 (the
  66.  * driver/host software).
  67.  *
  68.  * This is the control protocol used by the host to control the i2400m
  69.  * device (scan, connect, disconnect...). This is sent to / received
  70.  * as control frames. These frames consist of a header and zero or
  71.  * more TLVs with information. We call each control frame a "message".
  72.  *
  73.  * Each message is composed of:
  74.  *
  75.  * HEADER
  76.  * [TLV0 + PAYLOAD0]
  77.  * [TLV1 + PAYLOAD1]
  78.  * [...]
  79.  * [TLVN + PAYLOADN]
  80.  *
  81.  * The HEADER is defined by 'struct i2400m_l3l4_hdr'. The payloads are
  82.  * defined by a TLV structure (Type Length Value) which is a 'header'
  83.  * (struct i2400m_tlv_hdr) and then the payload.
  84.  *
  85.  * All integers are represented as Little Endian.
  86.  *
  87.  * - REQUESTS AND EVENTS
  88.  *
  89.  * The requests can be clasified as follows:
  90.  *
  91.  *   COMMAND:  implies a request from the host to the device requesting
  92.  *             an action being performed. The device will reply with a
  93.  *             message (with the same type as the command), status and
  94.  *             no (TLV) payload. Execution of a command might cause
  95.  *             events (of different type) to be sent later on as
  96.  *             device's state changes.
  97.  *
  98.  *   GET/SET:  similar to COMMAND, but will not cause other
  99.  *             EVENTs. The reply, in the case of GET, will contain
  100.  *             TLVs with the requested information.
  101.  *
  102.  *   EVENT:    asynchronous messages sent from the device, maybe as a
  103.  *             consequence of previous COMMANDs but disassociated from
  104.  *             them.
  105.  *
  106.  * Only one request might be pending at the same time (ie: don't
  107.  * parallelize nor post another GET request before the previous
  108.  * COMMAND has been acknowledged with it's corresponding reply by the
  109.  * device).
  110.  *
  111.  * The different requests and their formats are described below:
  112.  *
  113.  *  I2400M_MT_*   Message types
  114.  *  I2400M_MS_*   Message status (for replies, events)
  115.  *  i2400m_tlv_*  TLVs
  116.  *
  117.  * data types are named 'struct i2400m_msg_OPNAME', OPNAME matching the
  118.  * operation.
  119.  */
  120.  
  121. #ifndef __LINUX__WIMAX__I2400M_H__
  122. #define __LINUX__WIMAX__I2400M_H__
  123.  
  124. #include <linux/types.h>
  125.  
  126.  
  127. /*
  128.  * Host Device Interface (HDI) common to all busses
  129.  */
  130.  
  131. /* Boot-mode (firmware upload mode) commands */
  132.  
  133. /* Header for the firmware file */
  134. struct i2400m_bcf_hdr {
  135.     __le32 module_type;
  136.     __le32 header_len;
  137.     __le32 header_version;
  138.     __le32 module_id;
  139.     __le32 module_vendor;
  140.     __le32 date;        /* BCD YYYMMDD */
  141.     __le32 size;
  142.     __le32 key_size;    /* in dwords */
  143.     __le32 modulus_size;    /* in dwords */
  144.     __le32 exponent_size;    /* in dwords */
  145.     __u8 reserved[88];
  146. } __attribute__ ((packed));
  147.  
  148. /* Boot mode opcodes */
  149. enum i2400m_brh_opcode {
  150.     I2400M_BRH_READ = 1,
  151.     I2400M_BRH_WRITE = 2,
  152.     I2400M_BRH_JUMP = 3,
  153.     I2400M_BRH_SIGNED_JUMP = 8,
  154.     I2400M_BRH_HASH_PAYLOAD_ONLY = 9,
  155. };
  156.  
  157. /* Boot mode command masks and stuff */
  158. enum i2400m_brh {
  159.     I2400M_BRH_SIGNATURE = 0xcbbc0000,
  160.     I2400M_BRH_SIGNATURE_MASK = 0xffff0000,
  161.     I2400M_BRH_SIGNATURE_SHIFT = 16,
  162.     I2400M_BRH_OPCODE_MASK = 0x0000000f,
  163.     I2400M_BRH_RESPONSE_MASK = 0x000000f0,
  164.     I2400M_BRH_RESPONSE_SHIFT = 4,
  165.     I2400M_BRH_DIRECT_ACCESS = 0x00000400,
  166.     I2400M_BRH_RESPONSE_REQUIRED = 0x00000200,
  167.     I2400M_BRH_USE_CHECKSUM = 0x00000100,
  168. };
  169.  
  170.  
  171. /* Constants for bcf->module_id */
  172. enum i2400m_bcf_mod_id {
  173.     /* Firmware file carries its own pokes -- pokes are a set of
  174.      * magical values that have to be written in certain memory
  175.      * addresses to get the device up and ready for firmware
  176.      * download when it is in non-signed boot mode. */
  177.     I2400M_BCF_MOD_ID_POKES = 0x000000001,
  178. };
  179.  
  180.  
  181. /**
  182.  * i2400m_bootrom_header - Header for a boot-mode command
  183.  *
  184.  * @cmd: the above command descriptor
  185.  * @target_addr: where on the device memory should the action be performed.
  186.  * @data_size: for read/write, amount of data to be read/written
  187.  * @block_checksum: checksum value (if applicable)
  188.  * @payload: the beginning of data attached to this header
  189.  */
  190. struct i2400m_bootrom_header {
  191.     __le32 command;        /* Compose with enum i2400_brh */
  192.     __le32 target_addr;
  193.     __le32 data_size;
  194.     __le32 block_checksum;
  195.     char payload[0];
  196. } __attribute__ ((packed));
  197.  
  198.  
  199. /*
  200.  * Data / control protocol
  201.  */
  202.  
  203. /* Packet types for the host-device interface */
  204. enum i2400m_pt {
  205.     I2400M_PT_DATA = 0,
  206.     I2400M_PT_CTRL,
  207.     I2400M_PT_TRACE,    /* For device debug */
  208.     I2400M_PT_RESET_WARM,    /* device reset */
  209.     I2400M_PT_RESET_COLD,    /* USB[transport] reset, like reconnect */
  210.     I2400M_PT_EDATA,    /* Extended RX data */
  211.     I2400M_PT_ILLEGAL
  212. };
  213.  
  214.  
  215. /*
  216.  * Payload for a data packet
  217.  *
  218.  * This is prefixed to each and every outgoing DATA type.
  219.  */
  220. struct i2400m_pl_data_hdr {
  221.     __le32 reserved;
  222. } __attribute__((packed));
  223.  
  224.  
  225. /*
  226.  * Payload for an extended data packet
  227.  *
  228.  * New in fw v1.4
  229.  *
  230.  * @reorder: if this payload has to be reorder or not (and how)
  231.  * @cs: the type of data in the packet, as defined per (802.16e
  232.  *     T11.13.19.1). Currently only 2 (IPv4 packet) supported.
  233.  *
  234.  * This is prefixed to each and every INCOMING DATA packet.
  235.  */
  236. struct i2400m_pl_edata_hdr {
  237.     __le32 reorder;        /* bits defined in i2400m_ro */
  238.     __u8 cs;
  239.     __u8 reserved[11];
  240. } __attribute__((packed));
  241.  
  242. enum i2400m_cs {
  243.     I2400M_CS_IPV4_0 = 0,
  244.     I2400M_CS_IPV4 = 2,
  245. };
  246.  
  247. enum i2400m_ro {
  248.     I2400M_RO_NEEDED     = 0x01,
  249.     I2400M_RO_TYPE       = 0x03,
  250.     I2400M_RO_TYPE_SHIFT = 1,
  251.     I2400M_RO_CIN        = 0x0f,
  252.     I2400M_RO_CIN_SHIFT  = 4,
  253.     I2400M_RO_FBN        = 0x07ff,
  254.     I2400M_RO_FBN_SHIFT  = 8,
  255.     I2400M_RO_SN         = 0x07ff,
  256.     I2400M_RO_SN_SHIFT   = 21,
  257. };
  258.  
  259. enum i2400m_ro_type {
  260.     I2400M_RO_TYPE_RESET = 0,
  261.     I2400M_RO_TYPE_PACKET,
  262.     I2400M_RO_TYPE_WS,
  263.     I2400M_RO_TYPE_PACKET_WS,
  264. };
  265.  
  266.  
  267. /* Misc constants */
  268. enum {
  269.     I2400M_PL_ALIGN = 16,    /* Payload data size alignment */
  270.     I2400M_PL_SIZE_MAX = 0x3EFF,
  271.     I2400M_MAX_PLS_IN_MSG = 60,
  272.     /* protocol barkers: sync sequences; for notifications they
  273.      * are sent in groups of four. */
  274.     I2400M_H2D_PREVIEW_BARKER = 0xcafe900d,
  275.     I2400M_COLD_RESET_BARKER = 0xc01dc01d,
  276.     I2400M_WARM_RESET_BARKER = 0x50f750f7,
  277.     I2400M_NBOOT_BARKER = 0xdeadbeef,
  278.     I2400M_SBOOT_BARKER = 0x0ff1c1a1,
  279.     I2400M_ACK_BARKER = 0xfeedbabe,
  280.     I2400M_D2H_MSG_BARKER = 0xbeefbabe,
  281. };
  282.  
  283.  
  284. /*
  285.  * Hardware payload descriptor
  286.  *
  287.  * Bitfields encoded in a struct to enforce typing semantics.
  288.  *
  289.  * Look in rx.c and tx.c for a full description of the format.
  290.  */
  291. struct i2400m_pld {
  292.     __le32 val;
  293. } __attribute__ ((packed));
  294.  
  295. #define I2400M_PLD_SIZE_MASK 0x00003fff
  296. #define I2400M_PLD_TYPE_SHIFT 16
  297. #define I2400M_PLD_TYPE_MASK 0x000f0000
  298.  
  299. /*
  300.  * Header for a TX message or RX message
  301.  *
  302.  * @barker: preamble
  303.  * @size: used for management of the FIFO queue buffer; before
  304.  *     sending, this is converted to be a real preamble. This
  305.  *     indicates the real size of the TX message that starts at this
  306.  *     point. If the highest bit is set, then this message is to be
  307.  *     skipped.
  308.  * @sequence: sequence number of this message
  309.  * @offset: offset where the message itself starts -- see the comments
  310.  *     in the file header about message header and payload descriptor
  311.  *     alignment.
  312.  * @num_pls: number of payloads in this message
  313.  * @padding: amount of padding bytes at the end of the message to make
  314.  *           it be of block-size aligned
  315.  *
  316.  * Look in rx.c and tx.c for a full description of the format.
  317.  */
  318. struct i2400m_msg_hdr {
  319.     union {
  320.         __le32 barker;
  321.         __u32 size;    /* same size type as barker!! */
  322.     };
  323.     union {
  324.         __le32 sequence;
  325.         __u32 offset;    /* same size type as barker!! */
  326.     };
  327.     __le16 num_pls;
  328.     __le16 rsv1;
  329.     __le16 padding;
  330.     __le16 rsv2;
  331.     struct i2400m_pld pld[0];
  332. } __attribute__ ((packed));
  333.  
  334.  
  335.  
  336. /*
  337.  * L3/L4 control protocol
  338.  */
  339.  
  340. enum {
  341.     /* Interface version */
  342.     I2400M_L3L4_VERSION             = 0x0100,
  343. };
  344.  
  345. /* Message types */
  346. enum i2400m_mt {
  347.     I2400M_MT_RESERVED              = 0x0000,
  348.     I2400M_MT_INVALID               = 0xffff,
  349.     I2400M_MT_REPORT_MASK        = 0x8000,
  350.  
  351.     I2400M_MT_GET_SCAN_RESULT      = 0x4202,
  352.     I2400M_MT_SET_SCAN_PARAM       = 0x4402,
  353.     I2400M_MT_CMD_RF_CONTROL       = 0x4602,
  354.     I2400M_MT_CMD_SCAN             = 0x4603,
  355.     I2400M_MT_CMD_CONNECT          = 0x4604,
  356.     I2400M_MT_CMD_DISCONNECT       = 0x4605,
  357.     I2400M_MT_CMD_EXIT_IDLE       = 0x4606,
  358.     I2400M_MT_GET_LM_VERSION       = 0x5201,
  359.     I2400M_MT_GET_DEVICE_INFO      = 0x5202,
  360.     I2400M_MT_GET_LINK_STATUS      = 0x5203,
  361.     I2400M_MT_GET_STATISTICS       = 0x5204,
  362.     I2400M_MT_GET_STATE            = 0x5205,
  363.     I2400M_MT_GET_MEDIA_STATUS    = 0x5206,
  364.     I2400M_MT_SET_INIT_CONFIG    = 0x5404,
  365.     I2400M_MT_CMD_INIT            = 0x5601,
  366.     I2400M_MT_CMD_TERMINATE        = 0x5602,
  367.     I2400M_MT_CMD_MODE_OF_OP    = 0x5603,
  368.     I2400M_MT_CMD_RESET_DEVICE    = 0x5604,
  369.     I2400M_MT_CMD_MONITOR_CONTROL   = 0x5605,
  370.     I2400M_MT_CMD_ENTER_POWERSAVE   = 0x5606,
  371.     I2400M_MT_GET_TLS_OPERATION_RESULT = 0x6201,
  372.     I2400M_MT_SET_EAP_SUCCESS       = 0x6402,
  373.     I2400M_MT_SET_EAP_FAIL          = 0x6403,
  374.     I2400M_MT_SET_EAP_KEY              = 0x6404,
  375.     I2400M_MT_CMD_SEND_EAP_RESPONSE = 0x6602,
  376.     I2400M_MT_REPORT_SCAN_RESULT    = 0xc002,
  377.     I2400M_MT_REPORT_STATE        = 0xd002,
  378.     I2400M_MT_REPORT_POWERSAVE_READY = 0xd005,
  379.     I2400M_MT_REPORT_EAP_REQUEST    = 0xe002,
  380.     I2400M_MT_REPORT_EAP_RESTART    = 0xe003,
  381.     I2400M_MT_REPORT_ALT_ACCEPT        = 0xe004,
  382.     I2400M_MT_REPORT_KEY_REQUEST     = 0xe005,
  383. };
  384.  
  385.  
  386. /*
  387.  * Message Ack Status codes
  388.  *
  389.  * When a message is replied-to, this status is reported.
  390.  */
  391. enum i2400m_ms {
  392.     I2400M_MS_DONE_OK                  = 0,
  393.     I2400M_MS_DONE_IN_PROGRESS         = 1,
  394.     I2400M_MS_INVALID_OP               = 2,
  395.     I2400M_MS_BAD_STATE                = 3,
  396.     I2400M_MS_ILLEGAL_VALUE            = 4,
  397.     I2400M_MS_MISSING_PARAMS           = 5,
  398.     I2400M_MS_VERSION_ERROR            = 6,
  399.     I2400M_MS_ACCESSIBILITY_ERROR      = 7,
  400.     I2400M_MS_BUSY                     = 8,
  401.     I2400M_MS_CORRUPTED_TLV            = 9,
  402.     I2400M_MS_UNINITIALIZED            = 10,
  403.     I2400M_MS_UNKNOWN_ERROR            = 11,
  404.     I2400M_MS_PRODUCTION_ERROR         = 12,
  405.     I2400M_MS_NO_RF                    = 13,
  406.     I2400M_MS_NOT_READY_FOR_POWERSAVE  = 14,
  407.     I2400M_MS_THERMAL_CRITICAL         = 15,
  408.     I2400M_MS_MAX
  409. };
  410.  
  411.  
  412. /**
  413.  * i2400m_tlv - enumeration of the different types of TLVs
  414.  *
  415.  * TLVs stand for type-length-value and are the header for a payload
  416.  * composed of almost anything. Each payload has a type assigned
  417.  * and a length.
  418.  */
  419. enum i2400m_tlv {
  420.     I2400M_TLV_L4_MESSAGE_VERSIONS = 129,
  421.     I2400M_TLV_SYSTEM_STATE = 141,
  422.     I2400M_TLV_MEDIA_STATUS = 161,
  423.     I2400M_TLV_RF_OPERATION = 162,
  424.     I2400M_TLV_RF_STATUS = 163,
  425.     I2400M_TLV_DEVICE_RESET_TYPE = 132,
  426.     I2400M_TLV_CONFIG_IDLE_PARAMETERS = 601,
  427.     I2400M_TLV_CONFIG_IDLE_TIMEOUT = 611,
  428.     I2400M_TLV_CONFIG_D2H_DATA_FORMAT = 614,
  429.     I2400M_TLV_CONFIG_DL_HOST_REORDER = 615,
  430. };
  431.  
  432.  
  433. struct i2400m_tlv_hdr {
  434.     __le16 type;
  435.     __le16 length;        /* payload's */
  436.     __u8   pl[0];
  437. } __attribute__((packed));
  438.  
  439.  
  440. struct i2400m_l3l4_hdr {
  441.     __le16 type;
  442.     __le16 length;        /* payload's */
  443.     __le16 version;
  444.     __le16 resv1;
  445.     __le16 status;
  446.     __le16 resv2;
  447.     struct i2400m_tlv_hdr pl[0];
  448. } __attribute__((packed));
  449.  
  450.  
  451. /**
  452.  * i2400m_system_state - different states of the device
  453.  */
  454. enum i2400m_system_state {
  455.     I2400M_SS_UNINITIALIZED = 1,
  456.     I2400M_SS_INIT,
  457.     I2400M_SS_READY,
  458.     I2400M_SS_SCAN,
  459.     I2400M_SS_STANDBY,
  460.     I2400M_SS_CONNECTING,
  461.     I2400M_SS_WIMAX_CONNECTED,
  462.     I2400M_SS_DATA_PATH_CONNECTED,
  463.     I2400M_SS_IDLE,
  464.     I2400M_SS_DISCONNECTING,
  465.     I2400M_SS_OUT_OF_ZONE,
  466.     I2400M_SS_SLEEPACTIVE,
  467.     I2400M_SS_PRODUCTION,
  468.     I2400M_SS_CONFIG,
  469.     I2400M_SS_RF_OFF,
  470.     I2400M_SS_RF_SHUTDOWN,
  471.     I2400M_SS_DEVICE_DISCONNECT,
  472.     I2400M_SS_MAX,
  473. };
  474.  
  475.  
  476. /**
  477.  * i2400m_tlv_system_state - report on the state of the system
  478.  *
  479.  * @state: see enum i2400m_system_state
  480.  */
  481. struct i2400m_tlv_system_state {
  482.     struct i2400m_tlv_hdr hdr;
  483.     __le32 state;
  484. } __attribute__((packed));
  485.  
  486.  
  487. struct i2400m_tlv_l4_message_versions {
  488.     struct i2400m_tlv_hdr hdr;
  489.     __le16 major;
  490.     __le16 minor;
  491.     __le16 branch;
  492.     __le16 reserved;
  493. } __attribute__((packed));
  494.  
  495.  
  496. struct i2400m_tlv_detailed_device_info {
  497.     struct i2400m_tlv_hdr hdr;
  498.     __u8 reserved1[400];
  499.     __u8 mac_address[6];
  500.     __u8 reserved2[2];
  501. } __attribute__((packed));
  502.  
  503.  
  504. enum i2400m_rf_switch_status {
  505.     I2400M_RF_SWITCH_ON = 1,
  506.     I2400M_RF_SWITCH_OFF = 2,
  507. };
  508.  
  509. struct i2400m_tlv_rf_switches_status {
  510.     struct i2400m_tlv_hdr hdr;
  511.     __u8 sw_rf_switch;    /* 1 ON, 2 OFF */
  512.     __u8 hw_rf_switch;    /* 1 ON, 2 OFF */
  513.     __u8 reserved[2];
  514. } __attribute__((packed));
  515.  
  516.  
  517. enum {
  518.     i2400m_rf_operation_on = 1,
  519.     i2400m_rf_operation_off = 2
  520. };
  521.  
  522. struct i2400m_tlv_rf_operation {
  523.     struct i2400m_tlv_hdr hdr;
  524.     __le32 status;    /* 1 ON, 2 OFF */
  525. } __attribute__((packed));
  526.  
  527.  
  528. enum i2400m_tlv_reset_type {
  529.     I2400M_RESET_TYPE_COLD = 1,
  530.     I2400M_RESET_TYPE_WARM
  531. };
  532.  
  533. struct i2400m_tlv_device_reset_type {
  534.     struct i2400m_tlv_hdr hdr;
  535.     __le32 reset_type;
  536. } __attribute__((packed));
  537.  
  538.  
  539. struct i2400m_tlv_config_idle_parameters {
  540.     struct i2400m_tlv_hdr hdr;
  541.     __le32 idle_timeout;    /* 100 to 300000 ms [5min], 100 increments
  542.                  * 0 disabled */
  543.     __le32 idle_paging_interval;    /* frames */
  544. } __attribute__((packed));
  545.  
  546.  
  547. enum i2400m_media_status {
  548.     I2400M_MEDIA_STATUS_LINK_UP = 1,
  549.     I2400M_MEDIA_STATUS_LINK_DOWN,
  550.     I2400M_MEDIA_STATUS_LINK_RENEW,
  551. };
  552.  
  553. struct i2400m_tlv_media_status {
  554.     struct i2400m_tlv_hdr hdr;
  555.     __le32 media_status;
  556. } __attribute__((packed));
  557.  
  558.  
  559. /* New in v1.4 */
  560. struct i2400m_tlv_config_idle_timeout {
  561.     struct i2400m_tlv_hdr hdr;
  562.     __le32 timeout;    /* 100 to 300000 ms [5min], 100 increments
  563.              * 0 disabled */
  564. } __attribute__((packed));
  565.  
  566. /* New in v1.4 -- for backward compat, will be removed */
  567. struct i2400m_tlv_config_d2h_data_format {
  568.     struct i2400m_tlv_hdr hdr;
  569.     __u8 format;         /* 0 old format, 1 enhanced */
  570.     __u8 reserved[3];
  571. } __attribute__((packed));
  572.  
  573. /* New in v1.4 */
  574. struct i2400m_tlv_config_dl_host_reorder {
  575.     struct i2400m_tlv_hdr hdr;
  576.     __u8 reorder;         /* 0 disabled, 1 enabled */
  577.     __u8 reserved[3];
  578. } __attribute__((packed));
  579.  
  580.  
  581. #endif /* #ifndef __LINUX__WIMAX__I2400M_H__ */
  582.